// utils/index.js
// 工具函数模块

import { message } from 'antd'

/**
 * Utils 工具函数模块，提供全局通用方法
 */
export const Utils = {
  /**
   * 显示页面提示（使用Ant Design的message组件）
   * @param {string} msg 提示内容
   * @param {string} type 提示类型：success, error, warning, info
   * @param {number} duration 显示时长（秒）
   */
  showToast(msg, type = 'info', duration = 2) {
    message[type](msg, duration)
  },

  /**
   * 角度转弧度
   * @param {number} degrees 角度值
   * @returns {number} 弧度值
   */
  degToRad(degrees) {
    return degrees * Math.PI / 180
  },

  /**
   * 弧度转角度
   * @param {number} radians 弧度值
   * @returns {number} 角度值
   */
  radToDeg(radians) {
    return radians * 180 / Math.PI
  },

  /**
   * 格式化数字
   * @param {number} value 数值
   * @param {number} decimals 小数位数
   * @returns {string} 格式化后的字符串
   */
  formatNumber(value, decimals = 2) {
    if (typeof value !== 'number' || isNaN(value)) {
      return '0.00'
    }
    return value.toFixed(decimals)
  },

  /**
   * 格式化时间
   * @param {number} seconds 秒数
   * @returns {string} 格式化后的时间字符串
   */
  formatTime(seconds) {
    if (typeof seconds !== 'number' || isNaN(seconds)) {
      return '0.00'
    }
    return seconds.toFixed(2)
  },

  /**
   * 获取数组最后N个元素
   * @param {Array} array 数组
   * @param {number} n 元素个数
   * @returns {Array} 最后N个元素
   */
  getLastN(array, n) {
    if (!Array.isArray(array) || n <= 0) {
      return []
    }
    return array.slice(-n)
  },

  /**
   * 计算数组平均值
   * @param {Array} array 数值数组
   * @returns {number} 平均值
   */
  calculateAverage(array) {
    if (!Array.isArray(array) || array.length === 0) {
      return 0
    }
    const sum = array.reduce((acc, val) => acc + (typeof val === 'number' ? val : 0), 0)
    return sum / array.length
  },

  /**
   * 限制数值在指定范围内
   * @param {number} value 数值
   * @param {number} min 最小值
   * @param {number} max 最大值
   * @returns {number} 限制后的数值
   */
  clamp(value, min, max) {
    return Math.min(Math.max(value, min), max)
  },

  /**
   * 线性插值
   * @param {number} start 起始值
   * @param {number} end 结束值
   * @param {number} t 插值参数 (0-1)
   * @returns {number} 插值结果
   */
  lerp(start, end, t) {
    return start + (end - start) * t
  },

  /**
   * 防抖函数
   * @param {Function} func 要防抖的函数
   * @param {number} wait 等待时间（毫秒）
   * @returns {Function} 防抖后的函数
   */
  debounce(func, wait) {
    let timeout
    return function executedFunction(...args) {
      const later = () => {
        clearTimeout(timeout)
        func(...args)
      }
      clearTimeout(timeout)
      timeout = setTimeout(later, wait)
    }
  },

  /**
   * 节流函数
   * @param {Function} func 要节流的函数
   * @param {number} limit 时间限制（毫秒）
   * @returns {Function} 节流后的函数
   */
  throttle(func, limit) {
    let inThrottle
    return function executedFunction(...args) {
      if (!inThrottle) {
        func.apply(this, args)
        inThrottle = true
        setTimeout(() => inThrottle = false, limit)
      }
    }
  },

  /**
   * 深拷贝对象
   * @param {*} obj 要拷贝的对象
   * @returns {*} 拷贝后的对象
   */
  deepClone(obj) {
    if (obj === null || typeof obj !== 'object') {
      return obj
    }
    if (obj instanceof Date) {
      return new Date(obj.getTime())
    }
    if (obj instanceof Array) {
      return obj.map(item => this.deepClone(item))
    }
    if (typeof obj === 'object') {
      const clonedObj = {}
      for (const key in obj) {
        if (obj.hasOwnProperty(key)) {
          clonedObj[key] = this.deepClone(obj[key])
        }
      }
      return clonedObj
    }
  },

  /**
   * 生成唯一ID
   * @returns {string} 唯一ID
   */
  generateId() {
    return Date.now().toString(36) + Math.random().toString(36).substr(2)
  },

  /**
   * 下载文件
   * @param {string} content 文件内容
   * @param {string} filename 文件名
   * @param {string} contentType 内容类型
   */
  downloadFile(content, filename, contentType = 'text/plain') {
    const blob = new Blob([content], { type: contentType })
    const url = URL.createObjectURL(blob)
    const link = document.createElement('a')
    link.href = url
    link.download = filename
    document.body.appendChild(link)
    link.click()
    document.body.removeChild(link)
    URL.revokeObjectURL(url)
  }
}
